/**
 * 单位管理相关API
 * 封装单位列表、详情、管理等功能的接口
 */

import request from './request.js';

// API路径配置
const API_ROUTES = {
  UNIT: {
    // 单位基础操作
    LIST: '/api/units/list',                // 获取单位列表
    DETAIL: '/api/units/detail',            // 获取单位详情
    CREATE: '/api/units/create',            // 创建单位
    UPDATE: '/api/units/update',            // 更新单位
    DELETE: '/api/units/delete',            // 删除单位
    
    // 单位成员
    MEMBERS: '/api/units/members',          // 获取单位成员
    ADD_MEMBER: '/api/units/member/add',    // 添加单位成员
    UPDATE_MEMBER: '/api/units/member/update', // 更新单位成员
    REMOVE_MEMBER: '/api/units/member/remove', // 移除单位成员
    
    // 单位权限
    ROLES: '/api/units/roles',              // 获取单位角色
    ADD_ROLE: '/api/units/role/add',        // 添加角色
    UPDATE_ROLE: '/api/units/role/update',  // 更新角色
    DELETE_ROLE: '/api/units/role/delete',  // 删除角色
    
    // 单位部门
    DEPARTMENTS: '/api/units/departments',  // 获取部门列表
    ADD_DEPARTMENT: '/api/units/department/add', // 添加部门
    UPDATE_DEPARTMENT: '/api/units/department/update', // 更新部门
    DELETE_DEPARTMENT: '/api/units/department/delete', // 删除部门
    
    // 单位统计
    STATS: '/api/units/stats',              // 单位统计
  }
};

/**
 * 单位API封装
 */
export default {
  /**
   * 获取单位列表
   * @param {Object} params - 查询参数 {page, limit}
   * @returns {Promise} 单位列表数据
   */
  getUnitList(params = {}) {
    return request({
      url: API_ROUTES.UNIT.LIST,
      method: 'GET',
      data: params
    });
  },
  
  /**
   * 获取单位详情
   * @param {String} unitId - 单位ID
   * @returns {Promise} 单位详情数据
   */
  getUnitDetail(unitId) {
    return request({
      url: API_ROUTES.UNIT.DETAIL,
      method: 'GET',
      data: { unitId }
    });
  },
  
  /**
   * 创建单位
   * @param {Object} unitData - 单位数据
   * @returns {Promise} 创建结果
   */
  createUnit(unitData) {
    return request({
      url: API_ROUTES.UNIT.CREATE,
      method: 'POST',
      data: unitData
    });
  },
  
  /**
   * 更新单位
   * @param {Object} unitData - 单位数据，包含unitId
   * @returns {Promise} 更新结果
   */
  updateUnit(unitData) {
    return request({
      url: API_ROUTES.UNIT.UPDATE,
      method: 'PUT',
      data: unitData
    });
  },
  
  /**
   * 删除单位
   * @param {String} unitId - 单位ID
   * @returns {Promise} 删除结果
   */
  deleteUnit(unitId) {
    return request({
      url: API_ROUTES.UNIT.DELETE,
      method: 'DELETE',
      data: { unitId }
    });
  },
  
  /**
   * 获取单位成员
   * @param {String} unitId - 单位ID
   * @param {Object} params - 查询参数 {departmentId, roleId, page, limit}
   * @returns {Promise} 成员数据
   */
  getUnitMembers(unitId, params = {}) {
    return request({
      url: API_ROUTES.UNIT.MEMBERS,
      method: 'GET',
      data: {
        unitId,
        ...params
      }
    });
  },
  
  /**
   * 添加单位成员
   * @param {String} unitId - 单位ID
   * @param {Object} memberData - 成员数据
   * @returns {Promise} 添加结果
   */
  addUnitMember(unitId, memberData) {
    return request({
      url: API_ROUTES.UNIT.ADD_MEMBER,
      method: 'POST',
      data: {
        unitId,
        ...memberData
      }
    });
  },
  
  /**
   * 更新单位成员
   * @param {String} unitId - 单位ID
   * @param {String} memberId - 成员ID
   * @param {Object} memberData - 成员数据
   * @returns {Promise} 更新结果
   */
  updateUnitMember(unitId, memberId, memberData) {
    return request({
      url: API_ROUTES.UNIT.UPDATE_MEMBER,
      method: 'PUT',
      data: {
        unitId,
        memberId,
        ...memberData
      }
    });
  },
  
  /**
   * 移除单位成员
   * @param {String} unitId - 单位ID
   * @param {String} memberId - 成员ID
   * @returns {Promise} 移除结果
   */
  removeUnitMember(unitId, memberId) {
    return request({
      url: API_ROUTES.UNIT.REMOVE_MEMBER,
      method: 'DELETE',
      data: {
        unitId,
        memberId
      }
    });
  },
  
  /**
   * 获取单位角色
   * @param {String} unitId - 单位ID
   * @returns {Promise} 角色数据
   */
  getUnitRoles(unitId) {
    return request({
      url: API_ROUTES.UNIT.ROLES,
      method: 'GET',
      data: { unitId }
    });
  },
  
  /**
   * 添加角色
   * @param {String} unitId - 单位ID
   * @param {Object} roleData - 角色数据
   * @returns {Promise} 添加结果
   */
  addUnitRole(unitId, roleData) {
    return request({
      url: API_ROUTES.UNIT.ADD_ROLE,
      method: 'POST',
      data: {
        unitId,
        ...roleData
      }
    });
  },
  
  /**
   * 更新角色
   * @param {String} unitId - 单位ID
   * @param {String} roleId - 角色ID
   * @param {Object} roleData - 角色数据
   * @returns {Promise} 更新结果
   */
  updateUnitRole(unitId, roleId, roleData) {
    return request({
      url: API_ROUTES.UNIT.UPDATE_ROLE,
      method: 'PUT',
      data: {
        unitId,
        roleId,
        ...roleData
      }
    });
  },
  
  /**
   * 删除角色
   * @param {String} unitId - 单位ID
   * @param {String} roleId - 角色ID
   * @returns {Promise} 删除结果
   */
  deleteUnitRole(unitId, roleId) {
    return request({
      url: API_ROUTES.UNIT.DELETE_ROLE,
      method: 'DELETE',
      data: {
        unitId,
        roleId
      }
    });
  },
  
  /**
   * 获取部门列表
   * @param {String} unitId - 单位ID
   * @returns {Promise} 部门数据
   */
  getUnitDepartments(unitId) {
    return request({
      url: API_ROUTES.UNIT.DEPARTMENTS,
      method: 'GET',
      data: { unitId }
    });
  },
  
  /**
   * 添加部门
   * @param {String} unitId - 单位ID
   * @param {Object} departmentData - 部门数据
   * @returns {Promise} 添加结果
   */
  addUnitDepartment(unitId, departmentData) {
    return request({
      url: API_ROUTES.UNIT.ADD_DEPARTMENT,
      method: 'POST',
      data: {
        unitId,
        ...departmentData
      }
    });
  },
  
  /**
   * 更新部门
   * @param {String} unitId - 单位ID
   * @param {String} departmentId - 部门ID
   * @param {Object} departmentData - 部门数据
   * @returns {Promise} 更新结果
   */
  updateUnitDepartment(unitId, departmentId, departmentData) {
    return request({
      url: API_ROUTES.UNIT.UPDATE_DEPARTMENT,
      method: 'PUT',
      data: {
        unitId,
        departmentId,
        ...departmentData
      }
    });
  },
  
  /**
   * 删除部门
   * @param {String} unitId - 单位ID
   * @param {String} departmentId - 部门ID
   * @returns {Promise} 删除结果
   */
  deleteUnitDepartment(unitId, departmentId) {
    return request({
      url: API_ROUTES.UNIT.DELETE_DEPARTMENT,
      method: 'DELETE',
      data: {
        unitId,
        departmentId
      }
    });
  },
  
  /**
   * 获取单位统计
   * @param {String} unitId - 单位ID
   * @param {Object} params - 查询参数 {timeRange}
   * @returns {Promise} 统计数据
   */
  getUnitStats(unitId, params = {}) {
    return request({
      url: API_ROUTES.UNIT.STATS,
      method: 'GET',
      data: {
        unitId,
        ...params
      }
    });
  }
}; 